// 此文件运行在Worker线程，不能直接访问Three.js对象，只做纯数据计算

// 三角形面积计算（纯数学方法，不依赖Three.js）
function calculateTriangleArea(p1: number[], p2: number[], p3: number[]): number {
    // 向量叉积计算面积
    const v1x = p2[0] - p1[0];
    const v1y = p2[1] - p1[1];
    const v1z = p2[2] - p1[2];
    const v2x = p3[0] - p1[0];
    const v2y = p3[1] - p1[1];
    const v2z = p3[2] - p1[2];
    
    // 叉积结果
    const crossX = v1y * v2z - v1z * v2y;
    const crossY = v1z * v2x - v1x * v2z;
    const crossZ = v1x * v2y - v1y * v2x;
    
    // 模长的一半即面积
    return Math.sqrt(crossX **2 + crossY** 2 + crossZ ** 2) * 0.5;
}

// Worker消息处理
self.onmessage = (e) => {
    const { 
        positions,  // 顶点位置数组（扁平化）
        indices,    // 索引数组
        count,      // 粒子数量
        minGlitterSize, 
        maxGlitterSize,
    } = e.data;

    try {
        // 1. 预计算三角形面积（最耗时步骤）
        const faceAreas: number[] = [];
        let totalArea = 0;
        
        if (indices) {
            for (let i = 0; i < indices.length; i += 3) {
                const v1Idx = indices[i] * 3;
                const v2Idx = indices[i + 1] * 3;
                const v3Idx = indices[i + 2] * 3;
                
                // 提取三个顶点坐标
                const p1 = [positions[v1Idx], positions[v1Idx + 1], positions[v1Idx + 2]];
                const p2 = [positions[v2Idx], positions[v2Idx + 1], positions[v2Idx + 2]];
                const p3 = [positions[v3Idx], positions[v3Idx + 1], positions[v3Idx + 2]];
                
                // 计算面积
                const area = calculateTriangleArea(p1, p2, p3);
                faceAreas.push(area);
                totalArea += area;
            }
        }

        // 2. 生成粒子位置和大小（次耗时步骤）
        const particlePositions: number[] = [];
        const particleSizes: number[] = [];
        
        if (indices && indices.length > 0 && totalArea > 0) {
            for (let i = 0; i < count; i++) {
                // 按面积加权选择三角形
                let random = Math.random() * totalArea;
                let faceIndex = 0;
                for (; faceIndex < faceAreas.length; faceIndex++) {
                    random -= faceAreas[faceIndex];
                    if (random <= 0) break;
                }

                // 生成三角形内随机点
                const fIdx = faceIndex * 3;
                const v1Idx = indices[fIdx] * 3;
                const v2Idx = indices[fIdx + 1] * 3;
                const v3Idx = indices[fIdx + 2] * 3;

                const p1 = [positions[v1Idx], positions[v1Idx + 1], positions[v1Idx + 2]];
                const p2 = [positions[v2Idx], positions[v2Idx + 1], positions[v2Idx + 2]];
                const p3 = [positions[v3Idx], positions[v3Idx + 1], positions[v3Idx + 2]];

                // 改进的三角形内插值（避免顶点扎堆）
                let u = Math.random();
                let v = Math.random();
                if (u + v > 1) {
                    u = 1 - u;
                    v = 1 - v;
                }
                const w = 1 - u - v;

                // 计算坐标
                const x = p1[0] * u + p2[0] * v + p3[0] * w;
                const y = p1[1] * u + p2[1] * v + p3[1] * w;
                const z = p1[2] * u + p2[2] * v + p3[2] * w;

                // 动态偏移
                const offset = Math.max(0.01, Math.min(0.05, faceAreas[faceIndex] * 2));
                particlePositions.push(
                    x + (Math.random() - 0.5) * offset,
                    y + (Math.random() - 0.5) * offset,
                    z + (Math.random() - 0.5) * offset
                );

                // 随机大小
                particleSizes.push(minGlitterSize + Math.random() * (maxGlitterSize - minGlitterSize));
            }
        }

        // 3. 计算完成，向主线程发送结果
        self.postMessage({
            positions: particlePositions,
            sizes: particleSizes
        });

    } catch (error) {
        self.postMessage({ error: (error as Error).message });
    } finally {
        // 完成后终止Worker，释放资源
        self.close();
    }
};
